home *** CD-ROM | disk | FTP | other *** search
/ Hottest 6 / Hottest 6 (1996)(PDSoft)[!].iso / software / rendering / pov / povray40 / dump.c < prev    next >
C/C++ Source or Header  |  1978-11-24  |  9KB  |  338 lines
  1. /****************************************************************************
  2. *                   dump.c
  3. *
  4. *  This module contains the code to read and write the dump file format.
  5. *  The format is as follows:
  6. *
  7. *  (header:)
  8. *    wwww hhhh       - Width, Height (16 bits, LSB first)
  9. *
  10. *  (each scanline:)
  11. *    llll            - Line number (16 bits, LSB first)
  12. *    rr rr rr ...    - Red data for line (8 bits per pixel,
  13. *                       left to right, 0-255 (255=bright, 0=dark))
  14. *    gg gg gg ...    - Green data for line (8 bits per pixel,
  15. *                       left to right, 0-255 (255=bright, 0=dark))
  16. *    bb bb bb ...    - Blue data for line (8 bits per pixel,
  17. *                       left to right, 0-255 (255=bright, 0=dark))
  18. *
  19. *
  20. *
  21. *  from Persistence of Vision Raytracer
  22. *  Copyright 1992 Persistence of Vision Team
  23. *---------------------------------------------------------------------------
  24. *  Copying, distribution and legal info is in the file povlegal.doc which
  25. *  should be distributed with this file. If povlegal.doc is not available
  26. *  or for more info please contact:
  27. *
  28. *       Drew Wells [POV-Team Leader]
  29. *       CIS: 73767,1244  Internet: 73767.1244@compuserve.com
  30. *       Phone: (213) 254-4041
  31. *
  32. * This program is based on the popular DKB raytracer version 2.12.
  33. * DKBTrace was originally written by David K. Buck.
  34. * DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
  35. *
  36. *****************************************************************************/
  37.  
  38. #include "frame.h"
  39. #include "povproto.h"
  40.  
  41. FILE_HANDLE *Get_Dump_File_Handle()
  42. {
  43.    FILE_HANDLE *handle;
  44.  
  45.    if ((handle = (FILE_HANDLE *) malloc(sizeof(FILE_HANDLE))) == NULL) {
  46.       fprintf (stderr, "Cannot allocate memory for output file handle\n");
  47.       return(NULL);
  48.    }
  49.  
  50.    handle->Default_File_Name_p = Default_Dump_File_Name;
  51.    handle->Open_File_p = Open_Dump_File;
  52.    handle->Write_Line_p = Write_Dump_Line;
  53.    handle->Read_Line_p = Read_Dump_Line;
  54.    handle->Read_Image_p = Read_Dump_Image;
  55.    handle->Close_File_p = Close_Dump_File;
  56.    return (handle);
  57. }
  58.  
  59. char *Default_Dump_File_Name()
  60. {
  61.    return ("data.dis");
  62. }
  63.  
  64. int Open_Dump_File (handle, name, width, height, buffer_size, mode)
  65. FILE_HANDLE *handle;
  66. char *name;
  67. int *width;
  68. int *height;
  69. int buffer_size;
  70. int mode;
  71. {
  72.    int data1, data2;
  73.  
  74.    handle->mode = mode;
  75.    handle->filename = name;
  76.  
  77.    switch (mode) {
  78.    case READ_MODE:
  79.       if ((handle->file = fopen (name, READ_FILE_STRING)) == NULL) {
  80.          return(0);
  81.       }
  82.  
  83.       if (buffer_size != 0) {
  84.          if ((handle->buffer = malloc (buffer_size)) == NULL)
  85.             return(0);
  86.  
  87.          setvbuf (handle->file, handle->buffer, _IOFBF, buffer_size);
  88.       }
  89.  
  90.       if (((data1 = getc(handle->file)) == EOF)
  91.          || ((data2 = getc(handle->file)) == EOF))
  92.          return(0);
  93.  
  94.       *width  = data2 * 256 + data1;
  95.  
  96.       if (((data1 = getc(handle->file)) == EOF)
  97.          || ((data2 = getc(handle->file)) == EOF))
  98.          return(0);
  99.  
  100.       *height = data2 * 256 + data1;
  101.       handle->width = *width;
  102.       handle->height = *height;
  103.       handle->buffer_size = buffer_size;
  104.       break;
  105.  
  106.    case WRITE_MODE:
  107.       if ((handle->file = fopen (name, WRITE_FILE_STRING)) == NULL)
  108.          return(0);
  109.  
  110.       if (buffer_size != 0) {
  111.          if ((handle->buffer = malloc (buffer_size)) == NULL)
  112.             return(0);
  113.  
  114.          setvbuf (handle->file, handle->buffer, _IOFBF, buffer_size);
  115.       }
  116.  
  117.       putc((*width & 0xFF), handle->file);  /* write to either type of file */
  118.       putc(((*width >> 8 ) & 0xFF), handle->file);
  119.       putc((*height & 0xFF), handle->file);
  120.       putc(((*height >> 8 ) & 0xFF), handle->file);
  121.  
  122.       handle->width = *width;
  123.       handle->height = *height;
  124.       handle->buffer_size = buffer_size;
  125.  
  126.       break;
  127.  
  128.    case APPEND_MODE:
  129.       if ((handle->file = fopen (name, APPEND_FILE_STRING)) == NULL)
  130.          return(0);
  131.  
  132.       if (buffer_size != 0) {
  133.          if ((handle->buffer = malloc (buffer_size)) == NULL)
  134.             return(0);
  135.  
  136.          setvbuf (handle->file, handle->buffer, _IOFBF, buffer_size);
  137.       }
  138.  
  139.       handle->buffer_size = buffer_size;
  140.       break;
  141.    }
  142.    return(1);
  143. }
  144.  
  145. void Write_Dump_Line (handle, line_data, line_number)
  146. FILE_HANDLE *handle;
  147. COLOUR *line_data;
  148. int line_number;
  149. {
  150.    register int x;
  151.  
  152.    putc((line_number & 0xFF) , handle->file);
  153.    putc(((line_number >> 8) & 0xFF), handle->file);
  154.  
  155.    for (x = 0 ; x < handle->width ; x++)
  156.       putc((int) floor (line_data[x].Red * 255.0), handle->file);
  157.  
  158.    for (x = 0 ; x < handle->width ; x++)
  159.       putc((int) floor (line_data[x].Green * 255.0), handle->file);
  160.  
  161.    for (x = 0 ; x < handle->width ; x++)
  162.       putc((int) floor (line_data[x].Blue * 255.0), handle->file);
  163.  
  164.    if (handle->buffer_size == 0) {
  165.       fflush(handle->file);                       /* close and reopen file for */
  166.       handle->file = freopen(handle->filename, APPEND_FILE_STRING,
  167.          handle->file);                /* integrity in case we crash*/
  168.    }
  169. }
  170.  
  171. int Read_Dump_Line (handle, line_data, line_number)
  172. FILE_HANDLE *handle;
  173. COLOUR *line_data;
  174. int *line_number;
  175. {
  176.    int data, i, c;
  177.  
  178.    if ((c = getc(handle->file)) == EOF) {
  179.       return (0);
  180.    }
  181.  
  182.    *line_number = c;
  183.  
  184.    if ((c = getc(handle->file)) == EOF)
  185.       return (-1);
  186.  
  187.    *line_number += c*256;
  188.  
  189.    for (i = 0 ; i < handle->width ; i++) {
  190.       if ((data = getc(handle->file)) == EOF)
  191.          return(-1);
  192.  
  193.       line_data[i].Red = (DBL) data / 255.0;
  194.    }
  195.  
  196.    for (i = 0 ; i < handle->width ; i++) {
  197.       if ((data = getc(handle->file)) == EOF)
  198.          return(-1);
  199.  
  200.       line_data[i].Green = (DBL) data / 255.0;
  201.    }
  202.  
  203.    for (i = 0 ; i < handle->width ; i++) {
  204.       if ((data = getc(handle->file)) == EOF)
  205.          return(-1);
  206.  
  207.       line_data[i].Blue = (DBL) data / 255.0;
  208.    }
  209.  
  210.    return (1);
  211. }
  212.  
  213. int Read_Dump_Int_Line (handle, line_data, line_number)
  214. FILE_HANDLE *handle;
  215. IMAGE_LINE *line_data;
  216. int *line_number;
  217. {
  218.    int data, i, c;
  219.  
  220.    if ((c = getc(handle->file)) == EOF) {
  221.       return (0);
  222.    }
  223.  
  224.    *line_number = c;
  225.  
  226.    if ((c = getc(handle->file)) == EOF)
  227.       return (-1);
  228.  
  229.    *line_number += c*256;
  230.  
  231.    if (((line_data->red = (unsigned char *) malloc(handle->width))==NULL) ||
  232.       ((line_data->green = (unsigned char *) malloc(handle->width))==NULL) ||
  233.       ((line_data->blue = (unsigned char *) malloc(handle->width))==NULL)) {
  234.       fprintf (stderr, "Cannot allocate memory for picture: %s\n", handle->filename);
  235.       close_all();
  236.       exit(1);
  237.    }
  238.  
  239.    for (i = 0 ; i < handle->width ; i++) {
  240.       line_data->red[i] = 0;
  241.       line_data->green[i] = 0;
  242.       line_data->blue[i] = 0;
  243.    }
  244.  
  245.    for (i = 0 ; i < handle->width ; i++) {
  246.       if ((data = getc(handle->file)) == EOF)
  247.          return(-1);
  248.  
  249.       line_data->red[i] = (unsigned char) data;
  250.    }
  251.  
  252.    for (i = 0 ; i < handle->width ; i++) {
  253.       if ((data = getc(handle->file)) == EOF)
  254.          return(-1);
  255.  
  256.       line_data->green[i] = (unsigned char) data;
  257.    }
  258.  
  259.    for (i = 0 ; i < handle->width ; i++) {
  260.       if ((data = getc(handle->file)) == EOF)
  261.          return(-1);
  262.  
  263.       line_data->blue[i] = (unsigned char) data;
  264.    }
  265.  
  266.    return (1);
  267. }
  268.  
  269. void Close_Dump_File (handle)
  270. FILE_HANDLE *handle;
  271. {
  272.    if(handle->file)
  273.       fclose (handle->file);
  274.    if (handle->buffer_size != 0)
  275.       free (handle->buffer);
  276. }
  277.  
  278. void Read_Dump_Image(Image, name)
  279. IMAGE *Image;
  280. char *name;
  281. {
  282.    int rc, row, data1, data2;
  283.    struct Image_Line line;
  284.    FILE_HANDLE handle;
  285.  
  286.    if ((handle.file = Locate_File (name, READ_FILE_STRING)) == NULL) {
  287.       fprintf (stderr, "Cannot open dump file %s\n", name);
  288.       close_all();
  289.       exit(1);
  290.    }
  291.  
  292.    if (((data1 = getc(handle.file)) == EOF)
  293.       || ((data2 = getc(handle.file)) == EOF)) {
  294.  
  295.       fprintf (stderr, "Cannot open dump file %s\n", name);
  296.       close_all();
  297.       exit(1);
  298.    }
  299.  
  300.    Image->iwidth  = data2 * 256 + data1;
  301.    handle.width = Image->iwidth;
  302.  
  303.    if (((data1 = getc(handle.file)) == EOF)
  304.       || ((data2 = getc(handle.file)) == EOF)) {
  305.  
  306.       fprintf (stderr, "Cannot open dump file %s\n", name);
  307.       close_all();
  308.       exit(1);
  309.    }
  310.  
  311.    Image->iheight = data2 * 256 + data1;
  312.    handle.height = Image->iheight;
  313.  
  314.    Image->width = (DBL)Image->iwidth;
  315.    Image->height = (DBL)Image->iheight;
  316.  
  317.    Image->Colour_Map_Size = 0;
  318.    Image->Colour_Map = NULL;
  319.  
  320.    if ((Image->data.rgb_lines = (struct Image_Line *)
  321.       malloc(Image->iheight * sizeof (struct Image_Line))) == NULL) {
  322.       fprintf (stderr, "Cannot allocate memory for picture: %s\n", name);
  323.       exit(1);
  324.    }
  325.  
  326.    while ((rc = Read_Dump_Int_Line(&handle, &line, &row)) == 1)
  327.       Image->data.rgb_lines[row] = line;
  328.  
  329.    fclose (handle.file);
  330.  
  331.    if (rc == 0)
  332.       return;
  333.    else {
  334.       close_all();
  335.       exit(1);
  336.    }
  337. }
  338.